home *** CD-ROM | disk | FTP | other *** search
/ Dr. Windows 3 / dr win3.zip / dr win3 / PROGRAMR / GSRC208A.ZIP / EDRATEQ.C < prev    next >
C/C++ Source or Header  |  1993-07-13  |  20KB  |  738 lines
  1. #include "copyleft.h"
  2.  
  3. /*
  4.     GEPASI - a simulator of metabolic pathways and other dynamical systems
  5.     Copyright (C) 1989, 1992  Pedro Mendes
  6. */
  7.  
  8. /*************************************/
  9. /*                                   */
  10. /*          GWTOP - Topology         */
  11. /*        MS-WINDOWS front end       */
  12. /*                                   */
  13. /*       User-defined kinetics       */
  14. /*                                   */
  15. /*           QuickC/WIN 1.0          */
  16. /*                                   */
  17. /*   (include here compilers that    */
  18. /*   compiled GWSIM successfully)    */
  19. /*                                   */
  20. /*************************************/
  21.  
  22.  
  23. #include <windows.h>
  24. #include <stdio.h>
  25. #include <string.h>
  26. #include <stdlib.h>
  27. #include "defines.h"                    /* symbols also used in .DLG files        */
  28. #include "globals.h"                    /* gepasi's own symbols                    */
  29. #include "gwtop.h"                        /* macros, function prototypes, etc.    */
  30. #include "gep1.h"                        /* gepasi's variables                    */
  31. #include "topgvar.h"                    /* global variables                        */
  32. #include "strtbl.h"                        /* symbols for the string table            */
  33.  
  34. #define YY_NULL 0
  35. int rightprec( unsigned char nu );
  36. int leftprec( unsigned char nu );
  37. unsigned char parse_prim( void );
  38. unsigned char parse_expr( int priority );
  39. int lexic( char *line );
  40. int point_error( char *b );
  41. int yylex( void );
  42. void yyreset( void );
  43. void AddKLst( HWND hControl, int idx );
  44.  
  45. #pragma alloc_text( CODE1, rightprec, leftprec, parse_expr, parse_prim, lexic, point_error, EdRateq, EdRDet, EdNSub, AddKLst, EdUdkt)
  46.  
  47. int errfl, errnode;
  48. extern char *yyin;
  49.  
  50. int rightprec( unsigned char nu )
  51. {
  52.  int n;
  53.  
  54.  n = (int) nu;
  55.  switch( tr.node[n].item )
  56.  {
  57.   case 'N':
  58.   case 'I': return 6;
  59.   case 'F': return 4;
  60.  }
  61.  switch( tr.node[n].val )
  62.  {
  63.   case '+':
  64.   case '-': return 2;
  65.   case '*':
  66.   case '/': return 4;
  67.   case ')': return 6;
  68.   case '^': return 4;
  69.   case '(':
  70.   case '%': return 0;
  71.  }
  72. }
  73.  
  74. int leftprec( unsigned char nu )
  75. {
  76.  int n;
  77.  
  78.  n = (int) nu;
  79.  switch( tr.node[n].item )
  80.  {
  81.   case 'N':
  82.   case 'I':
  83.   case 'F': return 5;
  84.  }
  85.  switch( tr.node[n].val )
  86.  {
  87.   case '+':
  88.   case '-': return 1;
  89.   case '*':
  90.   case '/': return 3;
  91.   case '(': return 6;
  92.   case '^': return 5;
  93.   case ')':
  94.   case '%': return 0;
  95.  }
  96. }
  97.  
  98. unsigned char parse_expr( int priority )
  99. {
  100.  unsigned char lhs, rhs, op;
  101.  
  102.  lhs = parse_prim();
  103.  if( lhs == (unsigned char) 255 ) return (unsigned char) 255;
  104.  
  105.  for( ; tr.node[(int)lex].item=='O' && priority < leftprec( lex ); )
  106.  {
  107.   op = lex;
  108.   rhs = (unsigned char) 255;
  109.   ++lex;
  110.   rhs = parse_expr( rightprec( op ) );
  111.   if( rhs == (unsigned char) 255 )
  112.   {
  113.    if( !errfl )
  114.    {
  115.     sprintf( errstr, "ERROR - unexpected operator" );
  116.     errnode = (int) op;
  117.    }
  118.    errfl++;
  119.   }
  120.   else
  121.   {
  122.    tr.node[(int)op].left = lhs;
  123.    tr.node[(int)op].right = rhs;
  124.    lhs = op ;
  125.   }
  126.  }
  127.  
  128.  return lhs;
  129. }
  130.  
  131. unsigned char parse_prim( void )
  132. {
  133.  unsigned char nodep, op, primary;
  134.  char t;
  135.  
  136.  nodep = (unsigned char) 255;
  137.  
  138.  if( (tr.node[(int)lex].item=='N') || (tr.node[(int)lex].item=='I') ) t='K';
  139.  else t = tr.node[(int)lex].val;
  140.  
  141.  switch( t )
  142.  {
  143.   case 'K': tr.node[(int)lex].left = tr.node[(int)lex].right = (unsigned char) 255;
  144.             nodep = lex;
  145.             ++lex;
  146.             return nodep;
  147.  
  148.   case '(': ++lex;
  149.             nodep = parse_expr( 0 );
  150.             if( (tr.node[(int)lex].item=='O') && (tr.node[(int)lex].val==')') )
  151.             {
  152.              ++lex;
  153.              return nodep;
  154.             }
  155.             else
  156.             {
  157.              if( !errfl )
  158.              {
  159.               sprintf( errstr, "ERROR - right bracket missing" );
  160.               errnode = (int) lex;
  161.              }
  162.              errfl++;
  163.             }
  164.  
  165.   case '+':
  166.   case '-':
  167.   case 'L':
  168.   case 'l':
  169.   case 'e':
  170.   case 'S':
  171.   case 'C': op = lex; primary = (unsigned char) 255;
  172.             ++lex;
  173.             primary = parse_prim();
  174.             if( primary==(unsigned char)255 )
  175.             {
  176.              if( !errfl )
  177.              {
  178.               sprintf( errstr, "ERROR - missing operator" );
  179.               errnode = (int) op;
  180.              }
  181.              errfl++;
  182.             }
  183.             else
  184.             {
  185.              nodep = op;
  186.              tr.node[(int)op].item = 'F';
  187.              tr.node[(int)op].left = primary;
  188.              tr.node[(int)op].right = (unsigned char) 255;
  189.              return nodep;
  190.             }
  191.   default:  return (unsigned char) 255;
  192.  }
  193.  
  194.  if( (tr.node[(int)lex].item=='O') &&
  195.      (tr.node[(int)lex].val=='(')
  196.    )
  197.  {
  198.   ++lex;
  199.   if( (tr.node[(int)lex].item=='O') &&
  200.       (tr.node[(int)lex].val==')')
  201.     )
  202.   {
  203.    tr.node[(int)lex].left = nodep;
  204.    tr.node[(int)lex].right = (unsigned char) 255;
  205.    return lex;
  206.   }
  207.   else parse_expr( 0 );
  208.  }
  209. }
  210.  
  211. int lexic( char *line )
  212. {
  213.  int i;
  214.  
  215.  for( i=1; i<255; i++ )
  216.   tr.node[i].left = tr.node[i].right = 0;
  217.  
  218.  tr.node[0].item='%';
  219.  tr.node[0].val='%';
  220.  tr.node[0].right=(unsigned char) 255;
  221.  
  222.  yyreset();
  223.  tr.nnode = 1;
  224.  tr.nid = 0;
  225.  tr.nnum = 0;
  226.  yyin = line;
  227.  lex = 1;
  228.  
  229.  for( errfl=0; ; )
  230.  {
  231.   if( tr.nnode==254 )
  232.   {
  233.    if( !errfl )
  234.     sprintf( errstr, "ERROR - expression too long" );
  235.    errfl++;
  236.    break;
  237.   }
  238.   if( yylex() == YY_NULL ) break;
  239.  }
  240.  
  241.  if( !errfl ) tr.node[0].left = parse_expr( 0 );
  242.  
  243.  if( (tr.node[tr.node[0].left].item == 'O') &&
  244.      (tr.node[tr.node[0].left].val == '(' )
  245.    )
  246.  {
  247.   sprintf( errstr, "ERROR - missing operand" );
  248.   errnode = tr.node[0].left - 1;
  249.   errfl++;
  250.  }
  251.  
  252.  for( i=1; (i<tr.nnode)&&(!errfl); i++ )
  253.  {
  254.   switch( tr.node[i].item )
  255.   {
  256.    case 'O': if( ( tr.node[i].left  == (unsigned char) 255 ) ||
  257.                  ( tr.node[i].right == (unsigned char) 255 ) ||
  258.                  ( tr.node[i].left == (unsigned char) 0 )    ||
  259.                  ( tr.node[i].right == (unsigned char) 0 )
  260.                )
  261.               if( (tr.node[i].val!='(') && (tr.node[i].val!=')') )
  262.               {
  263.                if( !errfl )
  264.                {
  265.                 sprintf( errstr, "ERROR - incorrect number of operands" );
  266.                 errnode = i;
  267.                }
  268.                errfl++;
  269.               }
  270.              if( !errfl )
  271.              {
  272.               if( (tr.node[tr.node[i].left].item == 'O') &&
  273.                   (tr.node[tr.node[i].left].val == '(')
  274.                 )
  275.               {
  276.                sprintf( errstr, "ERROR - missing operand" );
  277.                errnode = tr.node[i].left - 1;
  278.                errfl++;
  279.               }
  280.               if( (tr.node[tr.node[i].right].item == 'O') &&
  281.                   (tr.node[tr.node[i].right].val == ')')
  282.                 )
  283.               {
  284.                sprintf( errstr, "ERROR - missing operand" );
  285.                errnode = tr.node[i].right - 1;
  286.                errfl++;
  287.               }
  288.              }
  289.              break;
  290.  
  291.    case 'I': if( ( tr.node[i].left == (unsigned char) 0 )  ||
  292.                  ( tr.node[i].right == (unsigned char) 0 )
  293.                )
  294.              {
  295.               if( !errfl )
  296.               {
  297.                sprintf( errstr, "ERROR - unexpected identifier" );
  298.                errnode = i-1;
  299.               }
  300.               errfl++;
  301.              }
  302.              break;
  303.    case 'N': if( ( tr.node[i].left == (unsigned char) 0 )    ||
  304.                  ( tr.node[i].right == (unsigned char) 0 )       )
  305.              {
  306.               if( !errfl )
  307.               {
  308.                sprintf( errstr, "ERROR - unexpected constant" );
  309.                errnode = i-1;
  310.               }
  311.               errfl++;
  312.              }
  313.              break;
  314.   }
  315.  }
  316.  
  317.  return errfl;
  318. }
  319.  
  320. int point_error( char *b )
  321. {
  322.  int pt, i;
  323.  char astr[64];
  324.  
  325.  pt = 0;
  326.  strcpy( b, "" );
  327.  for( i=1; i<tr.nnode; i++ )
  328.  {
  329.   switch( tr.node[i].item )
  330.   {
  331.    case 'N': sprintf( astr, "%g", tr.constant[(int)tr.node[i].val] ); break;
  332.    case 'I': sprintf( astr, "%s", tr.id[(int)tr.node[i].val] ); break;
  333.    case 'O': sprintf( astr, "%c", tr.node[i].val ); break;
  334.    case 'F': switch( tr.node[i].val )
  335.              {
  336.               case '+': sprintf(